const express = require('express');
const router = express.Router();
const fs = require('fs-extra');
const path = require('path');
const { v4: uuidv4 } = require('uuid');
const { createLogger } = require('../utils/logger');
const dayjs = require('dayjs');
const utc = require('dayjs/plugin/utc');
const timezone = require('dayjs/plugin/timezone');
dayjs.extend(utc);
dayjs.extend(timezone);
const CHINA_TZ = 'Asia/Shanghai';
function chinaNow() { return dayjs().tz(CHINA_TZ).format('YYYY-MM-DD HH:mm:ss'); }

// 创建日志记录器
const logger = createLogger('storage-api');

// 存储配置文件路径
const STORAGE_CONFIG_FILE = path.join(__dirname, '../config/storage-configs.json');

// 确保配置文件存在
if (!fs.existsSync(STORAGE_CONFIG_FILE)) {
  fs.writeJSONSync(STORAGE_CONFIG_FILE, { configs: [] }, { spaces: 2 });
  logger.info('创建了新的存储配置文件');
}

/**
 * 读取存储配置
 * @returns {Array} 存储配置列表
 */
function readStorageConfigs() {
  try {
    const data = fs.readJSONSync(STORAGE_CONFIG_FILE);
    return data.configs || [];
  } catch (error) {
    logger.error('读取存储配置文件失败:', error);
    return [];
  }
}

/**
 * 保存存储配置
 * @param {Array} configs 存储配置列表
 */
function saveStorageConfigs(configs) {
  try {
    fs.writeJSONSync(STORAGE_CONFIG_FILE, { configs }, { spaces: 2 });
    return true;
  } catch (error) {
    logger.error('保存存储配置文件失败:', error);
    return false;
  }
}

/**
 * 获取所有存储配置
 */
router.get('/', (req, res) => {
  try {
    const configs = readStorageConfigs();
    
    // 返回配置列表，但隐藏敏感信息
    const safeConfigs = configs.map(config => {
      const { secretKey, ...safeConfig } = config;
      return {
        ...safeConfig,
        secretKey: secretKey ? '******' : '' // 隐藏密钥
      };
    });
    
    res.json({
      code: 200,
      message: '获取存储配置成功',
      data: safeConfigs
    });
  } catch (error) {
    logger.error('获取存储配置列表失败:', error);
    res.status(500).json({
      code: 500,
      message: '获取存储配置列表失败',
      error: error.message
    });
  }
});

/**
 * 获取单个存储配置
 */
router.get('/:id', (req, res) => {
  try {
    const configs = readStorageConfigs();
    const config = configs.find(c => c.id === req.params.id);
    
    if (!config) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    // 返回配置，但隐藏敏感信息
    const { secretKey, ...safeConfig } = config;
    
    res.json({
      code: 200,
      message: '获取存储配置成功',
      data: {
        ...safeConfig,
        secretKey: secretKey ? '******' : '' // 隐藏密钥
      }
    });
  } catch (error) {
    logger.error(`获取存储配置(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      code: 500,
      message: '获取存储配置失败',
      error: error.message
    });
  }
});

/**
 * 创建存储配置
 */
router.post('/', (req, res) => {
  try {
    const configs = readStorageConfigs();
    const newConfig = {
      ...req.body,
      id: uuidv4(),
      createTime: chinaNow()
    };
    
    // 如果设置为默认，则将其他配置设为非默认
    if (newConfig.isDefault) {
      configs.forEach(config => {
        config.isDefault = false;
      });
    }
    
    configs.push(newConfig);
    saveStorageConfigs(configs);
    
    // 返回新配置，但隐藏敏感信息
    const { secretKey, ...safeConfig } = newConfig;
    
    res.json({
      code: 200,
      message: '创建存储配置成功',
      data: {
        ...safeConfig,
        secretKey: secretKey ? '******' : '' // 隐藏密钥
      }
    });
  } catch (error) {
    logger.error('创建存储配置失败:', error);
    res.status(500).json({
      code: 500,
      message: '创建存储配置失败',
      error: error.message
    });
  }
});

/**
 * 更新存储配置
 */
router.put('/:id', (req, res) => {
  try {
    const configs = readStorageConfigs();
    const configIndex = configs.findIndex(c => c.id === req.params.id);
    
    if (configIndex === -1) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    const oldConfig = configs[configIndex];
    const updatedConfig = {
      ...oldConfig,
      ...req.body,
      id: req.params.id, // 确保ID不变
      updateTime: chinaNow()
    };
    
    // 如果请求中没有包含secretKey或为空，保留原有的secretKey
    if (!req.body.secretKey || req.body.secretKey === '******') {
      updatedConfig.secretKey = oldConfig.secretKey;
    }
    
    // 如果设置为默认，则将其他配置设为非默认
    if (updatedConfig.isDefault) {
      configs.forEach(config => {
        if (config.id !== req.params.id) {
          config.isDefault = false;
        }
      });
    }
    
    configs[configIndex] = updatedConfig;
    saveStorageConfigs(configs);
    
    // 返回更新后的配置，但隐藏敏感信息
    const { secretKey, ...safeConfig } = updatedConfig;
    
    res.json({
      code: 200,
      message: '更新存储配置成功',
      data: {
        ...safeConfig,
        secretKey: secretKey ? '******' : '' // 隐藏密钥
      }
    });
  } catch (error) {
    logger.error(`更新存储配置(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      code: 500,
      message: '更新存储配置失败',
      error: error.message
    });
  }
});

/**
 * 删除存储配置
 */
router.delete('/:id', (req, res) => {
  try {
    let configs = readStorageConfigs();
    const configToDelete = configs.find(c => c.id === req.params.id);
    
    if (!configToDelete) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    // 如果删除的是默认配置，需要选择新的默认配置
    const wasDefault = configToDelete.isDefault;
    
    configs = configs.filter(c => c.id !== req.params.id);
    
    // 如果删除的是默认配置且还有其他配置，则将第一个配置设为默认
    if (wasDefault && configs.length > 0) {
      configs[0].isDefault = true;
    }
    
    saveStorageConfigs(configs);
    
    res.json({
      code: 200,
      message: '删除存储配置成功'
    });
  } catch (error) {
    logger.error(`删除存储配置(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      code: 500,
      message: '删除存储配置失败',
      error: error.message
    });
  }
});

/**
 * 测试存储配置连接
 */
router.post('/test/:id', async (req, res) => {
  try {
    const configs = readStorageConfigs();
    const config = configs.find(c => c.id === req.params.id);
    
    if (!config) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    // 根据不同的存储类型执行不同的测试逻辑
    let testResult = { success: false, message: '不支持的存储类型' };
    
    switch (config.type) {
      case 'cos':
        testResult = await testCosConnection(config);
        break;
      case 'oss':
        testResult = await testOssConnection(config);
        break;
      case 'qiniu':
        testResult = await testQiniuConnection(config);
        break;
    }
    
    if (testResult.success) {
      res.json({
        code: 200,
        message: '连接测试成功',
        data: testResult
      });
    } else {
      res.status(400).json({
        code: 400,
        message: testResult.message || '连接测试失败',
        data: testResult
      });
    }
  } catch (error) {
    logger.error(`测试存储配置(ID: ${req.params.id})连接失败:`, error);
    res.status(500).json({
      code: 500,
      message: '测试连接失败',
      error: error.message
    });
  }
});

/**
 * 获取存储使用统计
 */
router.get('/stats/:id', async (req, res) => {
  try {
    const configs = readStorageConfigs();
    const config = configs.find(c => c.id === req.params.id);
    
    if (!config) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    // 根据不同的存储类型获取统计数据
    let statsResult = { success: false, message: '不支持的存储类型' };
    
    switch (config.type) {
      case 'cos':
        statsResult = await getCosBucketStats(config);
        break;
      case 'oss':
        statsResult = await getOssBucketStats(config);
        break;
      case 'qiniu':
        statsResult = await getQiniuBucketStats(config);
        break;
    }
    
    if (statsResult.success) {
      res.json({
        code: 200,
        message: '获取存储统计成功',
        data: statsResult.data
      });
    } else {
      res.status(400).json({
        code: 400,
        message: statsResult.message || '获取存储统计失败',
        data: null
      });
    }
  } catch (error) {
    logger.error(`获取存储统计(ID: ${req.params.id})失败:`, error);
    res.status(500).json({
      code: 500,
      message: '获取存储统计失败',
      error: error.message
    });
  }
});

/**
 * 验证存储配置
 */
router.post('/validate', async (req, res) => {
  try {
    const config = req.body;
    
    if (!config || !config.type) {
      return res.status(400).json({
        code: 400,
        message: '无效的存储配置'
      });
    }
    
    // 验证必填字段
    const requiredFields = ['name', 'type', 'region', 'bucket', 'domain', 'accessKey', 'secretKey'];
    const missingFields = requiredFields.filter(field => !config[field]);
    
    if (missingFields.length > 0) {
      return res.status(400).json({
        code: 400,
        message: `缺少必填字段: ${missingFields.join(', ')}`,
        data: { missingFields }
      });
    }
    
    // 验证配置名称唯一性
    const configs = readStorageConfigs();
    const existingConfig = configs.find(c => c.name === config.name && (!config.id || c.id !== config.id));
    
    if (existingConfig) {
      return res.status(400).json({
        code: 400,
        message: `配置名称 "${config.name}" 已存在`,
        data: { field: 'name', value: config.name }
      });
    }
    
    // 验证域名格式
    const domainRegex = /^(https?:\/\/)?([\da-z.-]+)\.([a-z.]{2,6})([/\w.-]*)*\/?$/;
    if (!domainRegex.test(config.domain)) {
      return res.status(400).json({
        code: 400,
        message: '域名格式无效',
        data: { field: 'domain', value: config.domain }
      });
    }
    
    // 验证配置是否可连接
    let testResult = { success: false, message: '不支持的存储类型' };
    
    switch (config.type) {
      case 'cos':
        testResult = await testCosConnection(config);
        break;
      case 'oss':
        testResult = await testOssConnection(config);
        break;
      case 'qiniu':
        testResult = await testQiniuConnection(config);
        break;
    }
    
    if (testResult.success) {
      res.json({
        code: 200,
        message: '配置验证成功',
        data: { valid: true, details: testResult }
      });
    } else {
      res.status(400).json({
        code: 400,
        message: testResult.message || '配置验证失败',
        data: { valid: false, details: testResult }
      });
    }
  } catch (error) {
    logger.error(`验证存储配置失败:`, error);
    res.status(500).json({
      code: 500,
      message: '验证存储配置失败',
      error: error.message
    });
  }
});

/**
 * 批量操作文件
 */
router.post('/batch-operation', async (req, res) => {
  try {
    const { storageId, operation, sourcePaths, targetPath } = req.body;
    
    if (!storageId || !operation || !sourcePaths || !Array.isArray(sourcePaths) || sourcePaths.length === 0) {
      return res.status(400).json({
        code: 400,
        message: '请求参数无效',
        data: { required: ['storageId', 'operation', 'sourcePaths'] }
      });
    }
    
    // 检查操作类型
    const validOperations = ['copy', 'move', 'delete'];
    if (!validOperations.includes(operation)) {
      return res.status(400).json({
        code: 400,
        message: `不支持的操作类型: ${operation}`,
        data: { validOperations }
      });
    }
    
    // 如果是复制或移动操作，需要目标路径
    if ((operation === 'copy' || operation === 'move') && !targetPath) {
      return res.status(400).json({
        code: 400,
        message: `${operation === 'copy' ? '复制' : '移动'}操作需要目标路径`,
        data: { required: ['targetPath'] }
      });
    }
    
    // 获取存储配置
    const configs = readStorageConfigs();
    const config = configs.find(c => c.id === storageId);
    
    if (!config) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    // 执行批量操作
    // 注意：这里只是模拟操作，实际应用中需要使用对应的SDK实现
    const results = {
      operation,
      totalFiles: sourcePaths.length,
      successCount: 0,
      failedCount: 0,
      details: []
    };
    
    // 模拟操作结果
    for (const sourcePath of sourcePaths) {
      try {
        // TODO: 这里应该调用实际的SDK方法执行操作
        // 暂时返回成功，等待真实API实现
        const success = true; // 暂时固定为成功
        
        if (success) {
          results.successCount++;
          results.details.push({
            path: sourcePath,
            success: true,
            targetPath: operation !== 'delete' ? path.join(targetPath, path.basename(sourcePath)) : null
          });
        } else {
          results.failedCount++;
          results.details.push({
            path: sourcePath,
            success: false,
            error: '操作失败'
          });
        }
      } catch (error) {
        results.failedCount++;
        results.details.push({
          path: sourcePath,
          success: false,
          error: error.message
        });
      }
    }
    
    res.json({
      code: 200,
      message: `批量${operation === 'copy' ? '复制' : operation === 'move' ? '移动' : '删除'}操作完成`,
      data: results
    });
  } catch (error) {
    logger.error(`批量操作失败:`, error);
    res.status(500).json({
      code: 500,
      message: '批量操作失败',
      error: error.message
    });
  }
});

/**
 * 列出存储目录内容
 */
router.get('/list-directory/:id', async (req, res) => {
  try {
    const { id } = req.params;
    const { path: dirPath = '' } = req.query;
    
    // 获取存储配置
    const configs = readStorageConfigs();
    const config = configs.find(c => c.id === id);
    
    if (!config) {
      return res.status(404).json({
        code: 404,
        message: '存储配置不存在'
      });
    }
    
    // 根据不同的存储类型列出目录
    let listResult = { success: false, message: '不支持的存储类型' };
    
    switch (config.type) {
      case 'cos':
        listResult = await listCosDirectory(config, dirPath);
        break;
      case 'oss':
        listResult = await listOssDirectory(config, dirPath);
        break;
      case 'qiniu':
        listResult = await listQiniuDirectory(config, dirPath);
        break;
    }
    
    if (listResult.success) {
      res.json({
        code: 200,
        message: '获取目录列表成功',
        data: listResult.data
      });
    } else {
      res.status(400).json({
        code: 400,
        message: listResult.message || '获取目录列表失败',
        data: null
      });
    }
  } catch (error) {
    logger.error(`获取目录列表失败:`, error);
    res.status(500).json({
      code: 500,
      message: '获取目录列表失败',
      error: error.message
    });
  }
});

/**
 * 测试腾讯云COS连接
 */
async function testCosConnection(config) {
  try {
    logger.info(`测试腾讯云COS连接: ${config.name}`);
    
    // 这里只是模拟测试，实际应用中应该使用COS SDK进行真实连接测试
    // const COS = require('cos-nodejs-sdk-v5');
    // const cos = new COS({
    //   SecretId: config.accessKey,
    //   SecretKey: config.secretKey
    // });
    // await cos.headBucket({
    //   Bucket: config.bucket,
    //   Region: config.region
    // });
    
    // 模拟测试成功
    return { 
      success: true, 
      message: '腾讯云COS连接成功',
      details: {
        bucket: config.bucket,
        region: config.region,
        domain: config.domain
      }
    };
  } catch (error) {
    logger.error(`测试腾讯云COS连接失败: ${error.message}`);
    return { success: false, message: `腾讯云COS连接失败: ${error.message}` };
  }
}

/**
 * 测试阿里云OSS连接
 */
async function testOssConnection(config) {
  try {
    logger.info(`测试阿里云OSS连接: ${config.name}`);
    
    // 这里只是模拟测试，实际应用中应该使用OSS SDK进行真实连接测试
    // const OSS = require('ali-oss');
    // const client = new OSS({
    //   accessKeyId: config.accessKey,
    //   accessKeySecret: config.secretKey,
    //   bucket: config.bucket,
    //   region: config.region
    // });
    // await client.getBucketInfo();
    
    // 模拟测试成功
    return { 
      success: true, 
      message: '阿里云OSS连接成功',
      details: {
        bucket: config.bucket,
        region: config.region,
        domain: config.domain
      }
    };
  } catch (error) {
    logger.error(`测试阿里云OSS连接失败: ${error.message}`);
    return { success: false, message: `阿里云OSS连接失败: ${error.message}` };
  }
}

/**
 * 测试七牛云连接
 */
async function testQiniuConnection(config) {
  try {
    logger.info(`测试七牛云连接: ${config.name}`);
    
    // 这里只是模拟测试，实际应用中应该使用七牛云SDK进行真实连接测试
    // const qiniu = require('qiniu');
    // const mac = new qiniu.auth.digest.Mac(config.accessKey, config.secretKey);
    // const bucketManager = new qiniu.rs.BucketManager(mac);
    // await new Promise((resolve, reject) => {
    //   bucketManager.getBucketInfo(config.bucket, (err, respBody, respInfo) => {
    //     if (err) reject(err);
    //     else if (respInfo.statusCode !== 200) reject(new Error(respBody.error));
    //     else resolve(respBody);
    //   });
    // });
    
    // 模拟测试成功
    return { 
      success: true, 
      message: '七牛云连接成功',
      details: {
        bucket: config.bucket,
        region: config.region,
        domain: config.domain
      }
    };
  } catch (error) {
    logger.error(`测试七牛云连接失败: ${error.message}`);
    return { success: false, message: `七牛云连接失败: ${error.message}` };
  }
}

/**
 * 获取腾讯云COS存储桶统计信息
 */
async function getCosBucketStats(config) {
  try {
    logger.info(`获取腾讯云COS存储桶统计: ${config.name}`);
    
    // TODO: 使用真实的COS SDK获取统计数据
    // const COS = require('cos-nodejs-sdk-v5');
    // const cos = new COS({
    //   SecretId: config.accessKey,
    //   SecretKey: config.secretKey
    // });
    
    // 暂时返回空数据，等待真实API实现
    const stats = {
      totalSize: 0,
      fileCount: 0,
      lastUpdated: chinaNow(),
      byApp: {
        'vue-base': {size: 0, fileCount:0},
        'vue-app1': {size: 0, fileCount:0},
        'vue-app2': {size: 0, fileCount:0},
        'vue-build': {size: 0, fileCount:0}
      }
    };
    
    logger.warn('COS存储统计API尚未实现，请配置真实的COS SDK');
    return { success: true, data: stats };
  } catch (error) {
    logger.error(`获取腾讯云COS存储桶统计失败: ${error.message}`);
    return { success: false, message: `获取腾讯云COS存储桶统计失败: ${error.message}` };
  }
}

/**
 * 获取阿里云OSS存储桶统计信息
 */
async function getOssBucketStats(config) {
  try {
    logger.info(`获取阿里云OSS存储桶统计: ${config.name}`);
    
    // TODO: 使用真实的OSS SDK获取统计数据
    // const OSS = require('ali-oss');
    // const client = new OSS({
    //   accessKeyId: config.accessKey,
    //   accessKeySecret: config.secretKey,
    //   bucket: config.bucket,
    //   region: config.region
    // });
    
    // 暂时返回空数据，等待真实API实现
    const stats = {
      totalSize: 0,
      fileCount: 0,
      lastUpdated: chinaNow(),
      byApp: {
        'vue-base': {size: 0, fileCount:0},
        'vue-app1': {size: 0, fileCount:0},
        'vue-app2': {size: 0, fileCount:0},
        'vue-build': {size: 0, fileCount:0}
      }
    };
    
    logger.warn('OSS存储统计API尚未实现，请配置真实的OSS SDK');
    return { success: true, data: stats };
  } catch (error) {
    logger.error(`获取阿里云OSS存储桶统计失败: ${error.message}`);
    return { success: false, message: `获取阿里云OSS存储桶统计失败: ${error.message}` };
  }
}

/**
 * 获取七牛云存储桶统计信息
 */
async function getQiniuBucketStats(config) {
  try {
    logger.info(`获取七牛云存储桶统计: ${config.name}`);
    
    // TODO: 使用真实的七牛云SDK获取统计数据
    // const qiniu = require('qiniu');
    // const mac = new qiniu.auth.digest.Mac(config.accessKey, config.secretKey);
    // const bucketManager = new qiniu.rs.BucketManager(mac);
    
    // 暂时返回空数据，等待真实API实现
    const stats = {
      totalSize: 0,
      fileCount: 0,
      lastUpdated: chinaNow(),
      byApp: {
        'vue-base': {size: 0, fileCount:0},
        'vue-app1': {size: 0, fileCount:0},
        'vue-app2': {size: 0, fileCount:0},
        'vue-build': {size: 0, fileCount:0}
      }
    };
    
    logger.warn('七牛云存储统计API尚未实现，请配置真实的七牛云SDK');
    return { success: true, data: stats };
  } catch (error) {
    logger.error(`获取七牛云存储桶统计失败: ${error.message}`);
    return { success: false, message: `获取七牛云存储桶统计失败: ${error.message}` };
  }
}

/**
 * 列出腾讯云COS目录内容
 */
async function listCosDirectory(config, dirPath) {
  try {
    logger.info(`列出腾讯云COS目录: ${config.name}/${dirPath}`);
    
    // TODO: 使用真实的COS SDK获取目录列表
    // const COS = require('cos-nodejs-sdk-v5');
    // const cos = new COS({
    //   SecretId: config.accessKey,
    //   SecretKey: config.secretKey
    // });
    
    // 暂时返回空数据，等待真实API实现
    const items = [];
    
    logger.warn('COS目录列表API尚未实现，请配置真实的COS SDK');
    
    return { 
      success: true, 
      data: {
        path: dirPath,
        items,
        parentPath: dirPath.includes('/') ? dirPath.substring(0, dirPath.lastIndexOf('/')) : ''
      }
    };
  } catch (error) {
    logger.error(`列出腾讯云COS目录失败: ${error.message}`);
    return { success: false, message: `列出腾讯云COS目录失败: ${error.message}` };
  }
}

/**
 * 列出阿里云OSS目录内容
 */
async function listOssDirectory(config, dirPath) {
  try {
    logger.info(`列出阿里云OSS目录: ${config.name}/${dirPath}`);
    
    // TODO: 使用真实的OSS SDK获取目录列表
    // const OSS = require('ali-oss');
    // const client = new OSS({
    //   accessKeyId: config.accessKey,
    //   accessKeySecret: config.secretKey,
    //   bucket: config.bucket,
    //   region: config.region
    // });
    
    // 暂时返回空数据，等待真实API实现
    const items = [];
    
    logger.warn('OSS目录列表API尚未实现，请配置真实的OSS SDK');
    
    return { 
      success: true, 
      data: {
        path: dirPath,
        items,
        parentPath: dirPath.includes('/') ? dirPath.substring(0, dirPath.lastIndexOf('/')) : ''
      }
    };
  } catch (error) {
    logger.error(`列出阿里云OSS目录失败: ${error.message}`);
    return { success: false, message: `列出阿里云OSS目录失败: ${error.message}` };
  }
}

/**
 * 列出七牛云目录内容
 */
async function listQiniuDirectory(config, dirPath) {
  try {
    logger.info(`列出七牛云目录: ${config.name}/${dirPath}`);
    
    // TODO: 使用真实的七牛云SDK获取目录列表
    // const qiniu = require('qiniu');
    // const mac = new qiniu.auth.digest.Mac(config.accessKey, config.secretKey);
    // const bucketManager = new qiniu.rs.BucketManager(mac);
    
    // 暂时返回空数据，等待真实API实现
    const items = [];
    
    logger.warn('七牛云目录列表API尚未实现，请配置真实的七牛云SDK');
    
    return { 
      success: true, 
      data: {
        path: dirPath,
        items,
        parentPath: dirPath.includes('/') ? dirPath.substring(0, dirPath.lastIndexOf('/')) : ''
      }
    };
  } catch (error) {
    logger.error(`列出七牛云目录失败: ${error.message}`);
    return { success: false, message: `列出七牛云目录失败: ${error.message}` };
  }
}

module.exports = router; 